Transform coding consists in coding temporal signals in the transform (frequency) domain. This transform notably makes it possible to use the frequency characteristics of the audio signals in order to optimize and enhance the performance of the coding. Use is, for example, made of the fact that a harmonic sound is represented in the frequency domain by a reduced number of spectral rays which can thus be coded concisely. The frequency masking effects are also used for example advantageously to format the coding noise in such a way that it is as little audible as possible.
Conventionally, coding and decoding by transform is performed by the application of five steps:                The digital audio stream (sampled at a given sampling frequency Fs) to be coded is cut up into frames of finite numbers of samples (for example 2N). Each frame conventionally overlaps the preceding frame by 50%.        A transform step is applied to the signal. In the case of the transform called MDCT (Modified Discrete Cosine Transform), a weighting window ha (called analysis window) of size L=2N is applied to each frame.        The weighted frame is “folded” according to a 2N to N transform. The “folding” of the frame T2N of size 2N weighted by ha to the frame TN of size N can, for example, be done as follows:        
                    [                                  ⁢                                                                                                                                                T                        N                                            ⁡                                              (                        k                        )                                                              =                                                                                            -                                                                                    T                                                              2                                ⁢                                N                                                                                      (                                                                                                                            3                                  ⁢                                  N                                                                2                                                            -                              k                              -                              1                                                        )                                                                          ⁢                                                                              h                            a                                                    (                                                                                                                    3                                ⁢                                N                                                            2                                                        -                            k                            -                            1                                                    )                                                                    -                                                                                                    T                                                          2                              ⁢                              N                                                                                (                                                                                                                    3                                ⁢                                N                                                            2                                                        +                            k                                                    )                                                ⁢                                                                              h                            a                                                    (                                                                                                                    3                                ⁢                                N                                                            2                                                        +                            k                                                    )                                                                                                                                                                                                                                    T                        N                                            ⁡                                              (                                                                              N                            ⁢                                                          /                                                        ⁢                            2                                                    +                          k                                                )                                                              =                                                                                                                        T                                                          2                              ⁢                              N                                                                                ⁡                                                      (                            k                            )                                                                          ⁢                                                                              h                            a                                                    ⁡                                                      (                            k                            )                                                                                              -                                                                                                    T                                                          2                              ⁢                              N                                                                                ⁡                                                      (                                                          N                              -                              k                              -                              1                                                        )                                                                          ⁢                                                                              h                            a                                                    ⁡                                                      (                                                          N                              -                              k                              -                              1                                                        )                                                                                                                                                                    ⁢                                                  ⁢                                                  ⁢            k                    ∈                      [                          0              ;                                                N                  ⁢                                      /                                    ⁢                  2                                -                1                                      ]                                              (        1        )                            a DCT IV is applied to the folded frame TN in order to obtain a frame of size N in the transformed domain. It is expressed as follows:        
            T      N      ′        ⁡          (      u      )        =                    2        M            ⁢                        ∑                      k            =            0                                N            -            1                          ⁢                                  ⁢                                            T              N                        ⁡                          (              k              )                                ⁢                      cos            ⁡                          [                                                π                  M                                ⁢                                  (                                      k                    +                                          1                      2                                                        )                                ⁢                                  (                                      u                    +                                          1                      2                                                        )                                            ]                                                          The frame in the transformed domain is then quantized by using a matched quantizer. The quantization makes it possible to reduce the size of the data to be transmitted but introduces a noise (audible or not) into the original frame. The higher the bit rate of the coding, the more this noise is reduced and the closer the quantized frame is to the original frame.        An inverse MDCT transform is applied in decoding to the quantized frame. It comprises two steps: the quantized frame of size N is converted into a frame of size N in the time domain TN* by using an inverse DCT IV (which is expressed as a direct transform).        A second step of “unfolding” from N to 2N is then applied to the time frame TN* of size N. Weighting windows hs, called synthesis windows, are applied to the frames T2N* of sizes 2N according to the following equation:        
                    [                                                                                                                                                T                                                  2                          ⁢                          N                                                *                                            ⁡                                              (                        k                        )                                                              =                                                                                            T                          N                          *                                                ⁡                                                  (                                                                                    N                              2                                                        +                            k                                                    )                                                                    ⁢                                                                        h                          s                                                ⁡                                                  (                          k                          )                                                                                                                                                                                                                                    T                                                  2                          ⁢                          N                                                *                                            ⁡                                              (                                                                              N                            2                                                    +                          k                                                )                                                              =                                                                  -                                                                              T                            N                            *                                                    ⁡                                                      (                                                          N                              -                              k                              -                              1                                                        )                                                                                              ⁢                                                                        h                          s                                                ⁡                                                  (                                                                                    N                              2                                                        +                            k                                                    )                                                                                                                                                                                                                                    T                                                  2                          ⁢                          N                                                *                                            ⁡                                              (                                                  N                          +                          k                                                )                                                              =                                                                  -                                                                              T                            N                            *                                                    ⁡                                                      (                                                                                          N                                2                                                            -                              k                              -                              1                                                        )                                                                                              ⁢                                                                        h                          s                                                ⁡                                                  (                                                      N                            +                            k                                                    )                                                                                                                                                                                                                                    T                                                  2                          ⁢                          N                                                *                                            (                                                                                                    3                            ⁢                            N                                                    2                                                +                        k                                            )                                        =                                                                  -                                                                              T                            N                            *                                                    ⁡                                                      (                            k                            )                                                                                              ⁢                                                                        h                          s                                                (                                                                                                            3                              ⁢                              N                                                        2                                                    +                          k                                                )                                                                                                                  ⁢                                                  ⁢            k                    ∈                      [                          0              ;                                                N                  ⁢                                      /                                    ⁢                  2                                -                1                                      ]                                              (        2        )                            The decoded audio stream is then synthesized by summing the overlapping parts of two consecutive frames.        
Note that this scheme extends to transforms that have a greater overlap, such as the ELTs for which the analysis and synthesis filters have a length L=2KN for an overlap of (2K−1)N. The MDCT is thus a particular case of the ELT with K=1.
For a transform and a given overlap, analysis and synthesis windows are determined which make it possible to obtain a so-called “perfect” reconstruction of the signal to be coded (in the absence of quantization).
The reconstruction can also be “quasi-perfect” reconstruction when the difference between the original X and reconstructed {circumflex over (X)} signals can be considered negligible. For example, in audio coding, a difference that has an error power 50 dB lower than the power of the processed signal X can be considered to be negligible.
For example, in the case where the analysis and synthesis windows do not change over two consecutive frames, they should observe the following perfect reconstruction conditions:
                    [                                                                                                                                                                                                      h                            a                                                    ⁡                                                      (                                                          N                              +                              k                                                        )                                                                          ⁢                                                                              h                            s                                                    ⁡                                                      (                                                          N                              +                              k                                                        )                                                                                              +                                                                                                    h                            a                                                    ⁡                                                      (                            k                            )                                                                          ⁢                                                                              h                            s                                                    ⁡                                                      (                            k                            )                                                                                                                =                    1                                                                                                                                                                                                                        h                            a                                                    ⁡                                                      (                                                          N                              +                              k                                                        )                                                                          ⁢                                                                              h                            s                                                    ⁡                                                      (                                                                                          2                                ⁢                                N                                                            -                              k                              -                              1                                                        )                                                                                              -                                                                                                    h                            a                                                    ⁡                                                      (                            k                            )                                                                          ⁢                                                                              h                            s                                                    ⁡                                                      (                                                          N                              -                              1                              -                              k                                                        )                                                                                                                =                    0                                                                        ⁢                                                  ⁢            k                    ∈                      [                          0              ;                              N                -                1                                      ]                                              (        3        )            
Thus, it will be easily understood that, in most codecs, the analysis and synthesis windows are stored in memory, they are either computed in advance and stored in ROM memory or initialized using formulae and nevertheless stored in RAM memory.
Most of the time, the analysis and synthesis windows are identical (hs(k)=ha(k)), sometimes except for an index reversal (hs(k)=ha(2N−1−k)), they then require only a single memory space of size 2N for their storage in memory.
The new codecs work with different frame sizes N, whether to manage a plurality of sampling frequencies, or to adapt the size of the analysis (and therefore synthesis) window to the audio content (for example in the case of transitions). In these codecs, the ROM or RAM memory contains as many analysis and/or synthesis windows as there are different frame sizes.
The coefficients (also called samples) of the analysis or synthesis windows of the coder or of the decoder, should be stored in memory in order to perform the analysis or synthesis transform. Obviously, in a particular case using transforms of different sizes, the weighting window for each of the sizes used must be represented in memory.
In the favorable case where the windows are symmetrical, only L/2 coefficients need to be stored, the other L/2 being deduced without any arithmetical operation from these stored coefficients. Thus, for an MDCT (K=1), if there is a need for a transform of size M and 2.M, then (M+2M)=3M coefficients must be stored if the windows are symmetrical and (2M+4M)=6M coefficients be stored otherwise. A typical example for audio coding is M=320 or M=1024. Thus, for the asymmetrical case, this means that 1920 and 6144 coefficients respectively must be stored.
Depending on the precision desired for the representation of the coefficients, 16 bits, even 24 bits, for each coefficient are needed. This means a not inconsiderable memory space for low-cost computers.
Analysis or synthesis window decimation techniques do exist.
A simple window decimation, for example in order to change from N samples to M (N being a multiple of M), consists in taking one sample in N/M with N/M being an integer>1.
Such a computation does not make it possible to observe the perfect reconstruction equation given in equation (3).
For example, in the case where the synthesis window is the temporal reversal of the analysis window, the following applies:hs(2N−k−1)=ha(k)=h(k)for kε[0;2N−1]  (4)The perfect reconstruction condition becomes:h(N+k)h(N−k−1)+h(k)h(2N−k−1)=1for kε[0;2N−1]  (5)A window conventionally used in coding to meet this condition is the Malvar sinusoidal window:
                                          h            ⁡                          (              k              )                                =                      sin            ⁢                                                  ⁢                          (                                                π                                      2                    ⁢                    N                                                  ⁢                                  (                                      k                    +                    0.5                                    )                                            )                                      ⁢                                  ⁢        for        ⁢                                  ⁢                  k          ∈                      [                          0              ;                                                2                  ⁢                  N                                -                1                                      ]                                              (        6        )            If the window h(k) is decimated by taking one sample in N/M, this window becomes:
                    h        *            ⁡              (        k        )              =                  h        (                  kN          M                )            =              sin        (                              π                          2              ⁢              N                                ⁢                      (                                          kN                M                            +              0.5                        )                          )              for      k    ∈          [              0        ;                              2            ⁢            M                    -          1                    ]      For h*(k) of size 2M to confirm the perfect reconstruction condition (in equation (3)),
                                          h            *                    ⁡                      (                          M              +              k                        )                          ⁢                              h            *                    ⁡                      (                          M              -              k              -              1                        )                              +                                    h            *                    ⁡                      (            k            )                          ⁢                              h            *                    ⁡                      (                                          2                ⁢                M                            -              k              -              1                        )                                =                                        cos            (                                          π                                  2                  ⁢                  N                                            ⁢                              (                                                      kN                    M                                    +                  0.5                                )                                      )                    ⁢                      cos            (                                          π                                  2                  ⁢                  N                                            ⁢                              (                                                      kN                    M                                    +                                      N                    M                                    -                  0.5                                )                                      )                          +                              sin            (                                          π                                  2                  ⁢                  N                                            ⁢                              (                                                      kN                    M                                    +                  0.5                                )                                      )                    ⁢                      sin            (                                          π                                  2                  ⁢                  N                                            ⁢                              (                                                      kN                    M                                    +                                      N                    M                                    -                  0.5                                )                                      )                              =      1                          ⁢    for                      ⁢          k      ∈              [                  0          ;                      M            -            1                          ]            N/M must be equal to 1; now, N/M is defined as an integer>1, therefore, for such a decimation, the perfect reconstruction condition cannot be confirmed.
The illustrative example taken here is easily generalized. Thus, by direct decimation of a basic window to obtain a window of reduced size, the perfect reconstruction property cannot be assured.
Weighting window interpolation techniques also exist. Such a technique is, for example, described in the published patent application EP 2319039.
This technique makes it possible to reduce the size of windows stored in ROM when a window of greater size is needed.
Thus, instead of storing a window of size 2N and a window of size 4N, the patent application proposes assigning the samples of the 2N window to one sample in two of the 4N window and storing in ROM only the missing 2N samples. The storage size in ROM is thus reduced from 4N+2N to 2N+2N.
However, this technique also requires a preliminary analysis and synthesis window computation before applying the actual transform.
There is therefore a need to store only a reduced number of analysis windows and synthesis windows in memory to apply transforms of different sizes while observing the perfect reconstruction conditions. Furthermore, there is felt to be a need to avoid the steps of preliminary computation of these windows before the coding by transform.